/**
 * 
 * 构成正方形的数量
 * 
 * 题目描述

输入 N 个互不相同的二维整数坐标，求这 N 个坐标可以构成的正方形数量。（内积为零的的两个向量垂直）

输入描述
第一行输入为 N，N 代表坐标数量，N 为正整数

N ≤ 100
之后的 N 行输入为坐标 x y 以空格分隔，x，y 为整数

-10 ≤ x, y ≤ 10

输出描述
输出可以构成的正方形数量
 * 
 */

 /**
  * 用例

  输入  
3
1 3
2 4
3 1

输出	0

说明	3个点不足以构成正方形

输入	
4
0 0
1 2
3 1
2 -1

输出	1
说明	此4点可构成正方形
  * 

  */

import java.util.Arrays;
import java.util.HashSet;
import java.util.Scanner;

/**
   * 
   * 解析
   * 其实当我们知道正方形相邻两点的坐标，即某条边的坐标后，就可以求出其余两点的坐标。
   * 
   * 先取 2 个坐标
   * A（x1, y1） B（x2,y2）  计算AB2点之间的 x 轴的差值 dx = Math.abs(x1 -x2)  y 轴的差值 dy = Math.abs(y1 -y2) 
   * C D2 点的坐标可以表示为 C（x2 + dy, y2 - dx）  D（x1+dy, y1-dx） 即
   * 
   * C（x2 + Math.abs(y1 -y2) , y2 - Math.abs(x1 -x2)
   * D（x1 + Math.abs(y1 -y2) , y1 - Math.abs(x1 -x2）
   * 
   * 此时  正方形的四个点均以得到计算
   * 
   * 一条边(A、B2点组成的线)最多可以组成2 个正方形，和上面对称的正方形
   * C D2 点的坐标可以表示为 C（x2 - dy, y2 + dx）  D（x1-dy, y1+dx） 即
   * 
   * C（x2 - Math.abs(y1 -y2) , y2 + Math.abs(x1 -x2)
   * D（x1 - Math.abs(y1 -y2) , y1 + Math.abs(x1 -x2）
   * 
   * 此时我们就得到了根据正方形任意相邻两点坐标，求另外两点坐标的公式了。
   * 因此，接下来我们只需要遍历出两个点，然后通过公式得出另外可能的两个点，
   * 再在所有点中查找是否存在可能的两点，若存在，则正方形count++。
   * 
   * 最后的正方形个数squareCount 需要除以 4，原因是，如果输入中真的存在如下图中的绿色
   * ，橙色点，则遍历过程中也会将绿色，橙色点遍历出来，然后求它们的可能正方形
   */

public class 构成正方形的数量 {

    public static void main(String[] args){

        try{

            //正方形个数
            int squareCount = 0;

            //获取屏幕输入
            Scanner scanner = new Scanner(System.in);

            //获取输入坐标数量
            int totalCount = Integer.parseInt(scanner.nextLine());

            //保存坐标数组
            String[] points = new String[totalCount];
            for(int i=0; i<totalCount; i++){

                points[i] = scanner.nextLine();

            }

            //转换集合，用来判断计算出来的点是否存在
            HashSet<String> pointSet = new HashSet<String>(Arrays.asList(points));

            //遍历拿到 2 个点计算可以组成的正方形

            for(int i=0; i<totalCount; i++){

                //取出 第 1 个点封装成的坐标
                int pointA[] = Arrays.stream(points[i].split(" ")).mapToInt(Integer::parseInt).toArray();
                int xA = pointA[0];
                int yA = pointA[1];

                for(int j=i+1; j<totalCount; j++){

                    //取出 第 2 个点封装成的坐标
                    int pointB[] = Arrays.stream(points[j].split(" ")).mapToInt(Integer::parseInt).toArray();
                    int xB = pointB[0];
                    int yB = pointB[1];

                    //计算第一个正方形的C、D 点坐标
                    //xc = x1 - (y1 - y2)
                    //yc = y1 + (x1 - x2)
                    //xD = x2 - (y1 - y2)
                    //yD = y2 + (x1 - x2)

                    //对称正方形

                    //xc2 = x1 + (y1 - y2)
                    //yc2 = y1 - (x1 - x2)
                    //xD2 = x2 + (y1 - y2)
                    //yD2 = y2 - (x1 - x2)

                    int xC = xA - (yA - yB);
                    int yC = yA + (xA - xB);

                    int xD = xB - (yA - yB);
                    int yD = yB + (xA - xB);

                    //判断这 2 个点是否存在
                    if(pointSet.contains(xC + " " + yC) && pointSet.contains(xD + " " + yD)){
                        squareCount++;
                    }

                    //计算第二个正方形的C、D 点坐标 和上面的正方形是对称的

                    int xC2 = xA + (yA - yB);
                    int yC2 = yA - (xA - xB);

                    int xD2 = xB + (yA - yB);
                    int yD2 = yB - (xA - xB);

                    //判断这 2 个点是否存在
                    if(pointSet.contains(xC2 + " " + yC2) && pointSet.contains(xD2 + " " + yD2)){
                        squareCount++;
                    }



                }

            }

            //输出
            System.out.println((int)(squareCount / 4));



        }catch(Exception e){
            e.printStackTrace();
        }

    }
    
}
